package com.xuan.qimen.core.fei.shijia;

import java.util.*;

/**
 * 常量集合
 */
public class FeiShiJiaQiMenMap extends FeiShiJiaQiMenConstant {

    /**
     * 地支
     * <p>十二时辰命名：夜半、鸡鸣、平旦、日出、早食、隅中、日中、日昳、晡时、日入、黄昏、人定</p>
     */
    public static final String[] DI_ZHI = {ZI_ZHI, CHOU_ZHI, YIN_ZHI, MAO_ZHI, CHEN_ZHI, SI_ZHI, WU_ZHI, WEI_ZHI, SHEN_ZHI, YOU_ZHI, XU_ZHI, HAI_ZHI};

    /**
     * 二十四小时对应十二地支
     */
    public static final Map<Integer, String> HOUR_ZHI = new HashMap<Integer, String>() {
        private static final long serialVersionUID = -1;

        {
            put(0, ZI_ZHI);    // 子
            put(1, CHOU_ZHI);  // 丑
            put(2, CHOU_ZHI);  // 丑
            put(3, YIN_ZHI);   // 寅
            put(4, YIN_ZHI);   // 寅
            put(5, MAO_ZHI);   // 卯
            put(6, MAO_ZHI);   // 卯
            put(7, CHEN_ZHI);  // 辰
            put(8, CHEN_ZHI);  // 辰
            put(9, SI_ZHI);    // 巳
            put(10, SI_ZHI);   // 巳
            put(11, WU_ZHI);   // 午
            put(12, WU_ZHI);   // 午
            put(13, WEI_ZHI);  // 未
            put(14, WEI_ZHI);  // 未
            put(15, SHEN_ZHI); // 申
            put(16, SHEN_ZHI); // 申
            put(17, YOU_ZHI);  // 酉
            put(18, YOU_ZHI);  // 酉
            put(19, XU_ZHI);   // 戌
            put(20, XU_ZHI);   // 戌
            put(21, HAI_ZHI);  // 亥
            put(22, HAI_ZHI);  // 亥
            put(23, ZI_ZHI);   // 子
        }

    };

    /**
     * 三元符头
     */
    public static final String[] SAN_YUAN_FU_TOU = {JIA_ZI, JIA_WU, JIA_YIN, JIA_SHEN, JIA_CHEN, JIA_XU, JI_MAO, JI_YOU, JI_SI, JI_HAI, JI_CHOU, JI_WEI};

    /**
     * 三元日柱
     */
    public static final Map<Integer, List<String>> SAN_YUAN_RI_ZHU = new HashMap<Integer, List<String>>() {
        private static final long serialVersionUID = -1;

        {
            put(0, Arrays.asList(JIA_ZI, JIA_WU, YI_CHOU, YI_WEI, BING_YIN, BING_SHEN, DING_MAO, DING_YOU, WU_CHEN, WU_XU, JI_MAO, JI_YOU, GENG_CHEN, GENG_XU, XIN_SI, XIN_HAI, REN_WU, REN_ZI, GUI_WEI, GUI_CHOU)); // 上元
            put(1, Arrays.asList(JIA_SHEN, JIA_YIN, YI_YOU, YI_MAO, BING_XU, BING_CEHN, DING_HAI, DING_SI, WU_ZI, WU_WU, JI_SI, JI_HAI, GENG_WU, GENG_ZI, XIN_WEI, XIN_CHOU, REN_SHEN, REN_YIN, GUI_YOU, GUI_MAO)); // 中元
            put(2, Arrays.asList(JIA_XU, JIA_CHEN, YI_HAI, YI_SI, BING_ZI, BING_WU, DING_CHOU, DING_WEI, WU_YIN, WU_SHEN, JI_CHOU, JI_WEI, GENG_YIN, GENG_SHEN, XIN_MAO, XIN_YOU, REN_CHEN, REN_XU, GUI_SI, GUI_HAI)); // 下元
        }

    };

//------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 二十四节气对应的阴阳遁
     */
    public static final Map<Integer, List<String>> YIN_YANG_DUN = new HashMap<Integer, List<String>>() {
        private static final long serialVersionUID = -1;

        {
            put(0, Arrays.asList(DONG_ZHI, XIAO_HAN, DA_HAN, LI_CHUN, YU_SHUI, JING_ZHE, CHUN_FEN, QING_MING, GU_YU, LI_XIA, XIAO_MAN, MANG_ZHONG)); // 阳遁
            put(1, Arrays.asList(XIA_ZHI, XIAO_SHU, DA_SHU, LI_QIU, CHU_SHU, BAI_LU, QIU_FEN, HAN_LU, SHUANG_JIANG, LI_DONG, XIAO_XUE, DA_XUE)); // 阴遁
        }

    };

    /**
     * 二十四节气对应局数
     */
    public static final Map<String, List<Integer>> JU_SHU = new HashMap<String, List<Integer>>() {
        private static final long serialVersionUID = -1;

        /*
            阳遁：
                冬至、惊蛰一七四，小寒二八五，
                大寒、春分三九六，雨水九六三，
                清明、立夏四一七，立春八五二，
                谷雨、小满五二八，芒种六三九。

            阴遁：
                夏至、白露九三六，小暑八二五，
                大暑、秋分七一四，立秋二五八，
                寒露、立冬六九三，处暑一四七，
                霜降、小雪五八二，大雪四七一。
         */

        {
            put(DONG_ZHI, Arrays.asList(1, 7, 4));     // 冬至上元用阳遁1局，中元用阳遁7局，下元用阳遁4局
            put(XIAO_HAN, Arrays.asList(2, 8, 5));     // 小寒上元用阳遁2局，中元用阳遁8局，下元用阳遁5局
            put(DA_HAN, Arrays.asList(3, 9, 6));       // 大寒上元用阳遁3局，中元用阳遁9局，下元用阳遁6局
            put(LI_CHUN, Arrays.asList(8, 5, 2));      // 立春上元用阳遁8局，中元用阳遁5局，下元用阳遁2局
            put(YU_SHUI, Arrays.asList(9, 6, 3));      // 雨水上元用阳遁9局，中元用阳遁6局，下元用阳遁3局
            put(JING_ZHE, Arrays.asList(1, 7, 4));     // 惊蛰上元用阳遁1局，中元用阳遁7局，下元用阳遁4局
            put(CHUN_FEN, Arrays.asList(3, 9, 6));     // 春分上元用阳遁3局，中元用阳遁9局，下元用阳遁6局
            put(QING_MING, Arrays.asList(4, 1, 7));    // 清明上元用阳遁4局，中元用阳遁1局，下元用阳遁7局
            put(GU_YU, Arrays.asList(5, 2, 8));        // 谷雨上元用阳遁5局，中元用阳遁2局，下元用阳遁8局
            put(LI_XIA, Arrays.asList(4, 1, 7));       // 立夏上元用阳遁4局，中元用阳遁1局，下元用阳遁7局
            put(XIAO_MAN, Arrays.asList(5, 2, 8));     // 小满上元用阳遁5局，中元用阳遁2局，下元用阳遁8局
            put(MANG_ZHONG, Arrays.asList(6, 3, 9));   // 芒种上元用阳遁6局，中元用阳遁3局，下元用阳遁9局
            put(XIA_ZHI, Arrays.asList(9, 3, 6));      // 夏至上元用阴遁9局，中元用阴遁3局，下元用阴遁6局
            put(XIAO_SHU, Arrays.asList(8, 2, 5));     // 小暑上元用阴遁8局，中元用阴遁2局，下元用阴遁5局
            put(DA_SHU, Arrays.asList(7, 1, 4));       // 大暑上元用阴遁7局，中元用阴遁1局，下元用阴遁4局
            put(LI_QIU, Arrays.asList(2, 5, 8));       // 立秋上元用阴遁2局，中元用阴遁5局，下元用阴遁8局
            put(CHU_SHU, Arrays.asList(1, 4, 7));      // 处暑上元用阴遁1局，中元用阴遁4局，下元用阴遁7局
            put(BAI_LU, Arrays.asList(9, 3, 6));       // 白露上元用阴遁9局，中元用阴遁3局，下元用阴遁6局
            put(QIU_FEN, Arrays.asList(7, 1, 4));      // 秋分上元用阴遁7局，中元用阴遁1局，下元用阴遁4局
            put(HAN_LU, Arrays.asList(6, 9, 3));       // 寒露上元用阴遁6局，中元用阴遁9局，下元用阴遁3局
            put(SHUANG_JIANG, Arrays.asList(5, 8, 2)); // 霜降上元用阴遁5局，中元用阴遁8局，下元用阴遁2局
            put(LI_DONG, Arrays.asList(6, 9, 3));      // 立冬上元用阴遁6局，中元用阴遁9局，下元用阴遁3局
            put(XIAO_XUE, Arrays.asList(5, 8, 2));     // 小雪上元用阴遁5局，中元用阴遁8局，下元用阴遁2局
            put(DA_XUE, Arrays.asList(4, 7, 1));       // 大雪上元用阴遁4局，中元用阴遁7局，下元用阴遁1局
        }

    };

    /**
     * 根据二十四节气获取八门
     */
    public static final Map<Integer, List<String>> IS_BA_MEN = new HashMap<Integer, List<String>>() {
        private static final long serialVersionUID = -1;

        {
            put(0, Arrays.asList("冬至", "小寒", "大寒")); // 休门
            put(1, Arrays.asList("立春", "雨水", "惊蛰")); // 生门
            put(2, Arrays.asList("春分", "清明", "谷雨")); // 伤门
            put(3, Arrays.asList("立夏", "小满", "芒种")); // 杜门
            put(4, Arrays.asList("夏至", "小暑", "大暑")); // 景门
            put(5, Arrays.asList("立秋", "处暑", "白露")); // 死门
            put(6, Arrays.asList("秋分", "寒露", "霜降")); // 惊门
            put(7, Arrays.asList("立冬", "小雪", "大雪")); // 开门
        }
    };

    /**
     * 六十甲子对应的旬首
     */
    public static final Map<String, List<String>> SIX_JIA_ZI_XUN_SHOU = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        {
            put(JIA_ZI, Arrays.asList(JIA_ZI, WU_GAN));       // 甲子：甲子（戊）
            put(JIA_XU, Arrays.asList(JIA_XU, JI_GAN));       // 甲戌：甲戌（己）
            put(JIA_SHEN, Arrays.asList(JIA_SHEN, GENG_GAN)); // 甲申：甲申（庚）
            put(JIA_WU, Arrays.asList(JIA_WU, XIN_GAN));      // 甲午：甲午（辛）
            put(JIA_CHEN, Arrays.asList(JIA_CHEN, REN_GAN));  // 甲辰：甲辰（壬）
            put(JIA_YIN, Arrays.asList(JIA_YIN, GUI_GAN));    // 甲寅：甲寅（癸）
            put(YI_CHOU, Arrays.asList(JIA_ZI, WU_GAN));      // 乙丑：甲子（戊）
            put(YI_HAI, Arrays.asList(JIA_XU, JI_GAN));       // 乙亥：甲戌（己）
            put(YI_YOU, Arrays.asList(JIA_SHEN, GENG_GAN));   // 乙酉：甲申（庚）
            put(YI_WEI, Arrays.asList(JIA_WU, XIN_GAN));      // 乙未：甲午（辛）
            put(YI_SI, Arrays.asList(JIA_CHEN, REN_GAN));     // 乙巳：甲辰（壬）
            put(YI_MAO, Arrays.asList(JIA_YIN, GUI_GAN));     // 乙卯：甲寅（癸）
            put(BING_YIN, Arrays.asList(JIA_ZI, WU_GAN));     // 丙寅：甲子（戊）
            put(BING_ZI, Arrays.asList(JIA_XU, JI_GAN));      // 丙子：甲戌（己）
            put(BING_XU, Arrays.asList(JIA_SHEN, GENG_GAN));  // 丙戌：甲申（庚）
            put(BING_SHEN, Arrays.asList(JIA_WU, XIN_GAN));   // 丙申：甲午（辛）
            put(BING_WU, Arrays.asList(JIA_CHEN, REN_GAN));   // 丙午：甲辰（壬）
            put(BING_CEHN, Arrays.asList(JIA_YIN, GUI_GAN));  // 丙辰：甲寅（癸）
            put(DING_MAO, Arrays.asList(JIA_ZI, WU_GAN));     // 丁卯：甲子（戊）
            put(DING_CHOU, Arrays.asList(JIA_XU, JI_GAN));    // 丁丑：甲戌（己）
            put(DING_HAI, Arrays.asList(JIA_SHEN, GENG_GAN)); // 丁亥：甲申（庚）
            put(DING_YOU, Arrays.asList(JIA_WU, XIN_GAN));    // 丁酉：甲午（辛）
            put(DING_WEI, Arrays.asList(JIA_CHEN, REN_GAN));  // 丁未：甲辰（壬）
            put(DING_SI, Arrays.asList(JIA_YIN, GUI_GAN));    // 丁巳：甲寅（癸）
            put(WU_CHEN, Arrays.asList(JIA_ZI, WU_GAN));      // 戊辰：甲子（戊）
            put(WU_YIN, Arrays.asList(JIA_XU, JI_GAN));       // 戊寅：甲戌（己）
            put(WU_ZI, Arrays.asList(JIA_SHEN, GENG_GAN));    // 戊子：甲申（庚）
            put(WU_XU, Arrays.asList(JIA_WU, XIN_GAN));       // 戊戌：甲午（辛）
            put(WU_SHEN, Arrays.asList(JIA_CHEN, REN_GAN));   // 戊申：甲辰（壬）
            put(WU_WU, Arrays.asList(JIA_YIN, GUI_GAN));      // 戊午：甲寅（癸）
            put(JI_SI, Arrays.asList(JIA_ZI, WU_GAN));        // 己巳：甲子（戊）
            put(JI_MAO, Arrays.asList(JIA_XU, JI_GAN));       // 己卯：甲戌（己）
            put(JI_CHOU, Arrays.asList(JIA_SHEN, GENG_GAN));  // 己丑：甲申（庚）
            put(JI_HAI, Arrays.asList(JIA_WU, XIN_GAN));      // 己亥：甲午（辛）
            put(JI_YOU, Arrays.asList(JIA_CHEN, REN_GAN));    // 己酉：甲辰（壬）
            put(JI_WEI, Arrays.asList(JIA_YIN, GUI_GAN));     // 己未：甲寅（癸）
            put(GENG_WU, Arrays.asList(JIA_ZI, WU_GAN));      // 庚午：甲子（戊）
            put(GENG_CHEN, Arrays.asList(JIA_XU, JI_GAN));    // 庚辰：甲戌（己）
            put(GENG_YIN, Arrays.asList(JIA_SHEN, GENG_GAN)); // 庚寅：甲申（庚）
            put(GENG_ZI, Arrays.asList(JIA_WU, XIN_GAN));     // 庚子：甲午（辛）
            put(GENG_XU, Arrays.asList(JIA_CHEN, REN_GAN));   // 庚戌：甲辰（壬）
            put(GENG_SHEN, Arrays.asList(JIA_YIN, GUI_GAN));  // 庚申：甲寅（癸）
            put(XIN_WEI, Arrays.asList(JIA_ZI, WU_GAN));      // 辛未：甲子（戊）
            put(XIN_SI, Arrays.asList(JIA_XU, JI_GAN));       // 辛巳：甲戌（己）
            put(XIN_MAO, Arrays.asList(JIA_SHEN, GENG_GAN));  // 辛卯：甲申（庚）
            put(XIN_CHOU, Arrays.asList(JIA_WU, XIN_GAN));    // 辛丑：甲午（辛）
            put(XIN_HAI, Arrays.asList(JIA_CHEN, REN_GAN));   // 辛亥：甲辰（壬）
            put(XIN_YOU, Arrays.asList(JIA_YIN, GUI_GAN));    // 辛酉：甲寅（癸）
            put(REN_SHEN, Arrays.asList(JIA_ZI, WU_GAN));     // 壬申：甲子（戊）
            put(REN_WU, Arrays.asList(JIA_XU, JI_GAN));       // 壬午：甲戌（己）
            put(REN_CHEN, Arrays.asList(JIA_SHEN, GENG_GAN)); // 壬辰：甲申（庚）
            put(REN_YIN, Arrays.asList(JIA_WU, XIN_GAN));     // 壬寅：甲午（辛）
            put(REN_ZI, Arrays.asList(JIA_CHEN, REN_GAN));    // 壬子：甲辰（壬）
            put(REN_XU, Arrays.asList(JIA_YIN, GUI_GAN));     // 壬戌：甲寅（癸）
            put(GUI_YOU, Arrays.asList(JIA_ZI, WU_GAN));      // 癸酉：甲子（戊）
            put(GUI_WEI, Arrays.asList(JIA_XU, JI_GAN));      // 癸未：甲戌（己）
            put(GUI_SI, Arrays.asList(JIA_SHEN, GENG_GAN));   // 癸巳：甲申（庚）
            put(GUI_MAO, Arrays.asList(JIA_WU, XIN_GAN));     // 癸卯：甲午（辛）
            put(GUI_CHOU, Arrays.asList(JIA_CHEN, REN_GAN));  // 癸丑：甲辰（壬）
            put(GUI_HAI, Arrays.asList(JIA_YIN, GUI_GAN));    // 癸亥：甲寅（癸）
        }

    };

//------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 地盘三奇六仪（阳遁1~9宫）
     */
    public static final Map<Integer, List<String>> DI_YANG_QI_YI = new HashMap<Integer, List<String>>() {
        private static final long serialVersionUID = -1;

        // 例如→ 阳遁一局：戊在坎一宫，己在坤二宫，庚在震三宫，辛在巽四宫，壬在中五宫、寄坤二宫，癸在乾六宫，丁在兑七宫，丙在艮八宫，乙在离九宫。
        {
            put(1, Arrays.asList(WU_GAN, JI_GAN, GENG_GAN, XIN_GAN, REN_GAN, GUI_GAN, DING_GAN, BING_GAN, YI_GAN)); // 阳遁一局（1~9宫）
            put(2, Arrays.asList(YI_GAN, WU_GAN, JI_GAN, GENG_GAN, XIN_GAN, REN_GAN, GUI_GAN, DING_GAN, BING_GAN)); // 阳遁二局（1~9宫）
            put(3, Arrays.asList(BING_GAN, YI_GAN, WU_GAN, JI_GAN, GENG_GAN, XIN_GAN, REN_GAN, GUI_GAN, DING_GAN)); // 阳遁三局（1~9宫）
            put(4, Arrays.asList(DING_GAN, BING_GAN, YI_GAN, WU_GAN, JI_GAN, GENG_GAN, XIN_GAN, REN_GAN, GUI_GAN)); // 阳遁四局（1~9宫）
            put(5, Arrays.asList(GUI_GAN, DING_GAN, BING_GAN, YI_GAN, WU_GAN, JI_GAN, GENG_GAN, XIN_GAN, REN_GAN)); // 阳遁五局（1~9宫）
            put(6, Arrays.asList(REN_GAN, GUI_GAN, DING_GAN, BING_GAN, YI_GAN, WU_GAN, JI_GAN, GENG_GAN, XIN_GAN)); // 阳遁六局（1~9宫）
            put(7, Arrays.asList(XIN_GAN, REN_GAN, GUI_GAN, DING_GAN, BING_GAN, YI_GAN, WU_GAN, JI_GAN, GENG_GAN)); // 阳遁七局（1~9宫）
            put(8, Arrays.asList(GENG_GAN, XIN_GAN, REN_GAN, GUI_GAN, DING_GAN, BING_GAN, YI_GAN, WU_GAN, JI_GAN)); // 阳遁八局（1~9宫）
            put(9, Arrays.asList("己", GENG_GAN, XIN_GAN, REN_GAN, GUI_GAN, DING_GAN, BING_GAN, YI_GAN, WU_GAN)); // 阳遁九局（1~9宫）
        }

    };

    /**
     * 地盘三奇六仪（阴遁1~9宫）
     */
    public static final Map<Integer, List<String>> DI_YIN_QI_YI = new HashMap<Integer, List<String>>() {
        private static final long serialVersionUID = -1;

        // 例如→ 阴遁一局：戊在坎一宫，乙在坤二宫，丙在震三宫，丁在巽四宫，癸在中五宫、坤二宫，壬在乾六宫，辛在兑七宫，庚在艮八宫，己在离九宫。
        {
            put(1, Arrays.asList(WU_GAN, YI_GAN, BING_GAN, DING_GAN, GUI_GAN, REN_GAN, XIN_GAN, GENG_GAN, JI_GAN)); // 阴遁一局（1~9宫）
            put(2, Arrays.asList(JI_GAN, WU_GAN, YI_GAN, BING_GAN, DING_GAN, GUI_GAN, REN_GAN, XIN_GAN, GENG_GAN)); // 阴遁二局（1~9宫）
            put(3, Arrays.asList(GENG_GAN, JI_GAN, WU_GAN, YI_GAN, BING_GAN, DING_GAN, GUI_GAN, REN_GAN, XIN_GAN)); // 阴遁三局（1~9宫）
            put(4, Arrays.asList(XIN_GAN, GENG_GAN, JI_GAN, WU_GAN, YI_GAN, BING_GAN, DING_GAN, GUI_GAN, REN_GAN)); // 阴遁四局（1~9宫）
            put(5, Arrays.asList(REN_GAN, XIN_GAN, GENG_GAN, JI_GAN, WU_GAN, YI_GAN, BING_GAN, DING_GAN, GUI_GAN)); // 阴遁五局（1~9宫）
            put(6, Arrays.asList(GUI_GAN, REN_GAN, XIN_GAN, GENG_GAN, JI_GAN, WU_GAN, YI_GAN, BING_GAN, DING_GAN)); // 阴遁六局（1~9宫）
            put(7, Arrays.asList(DING_GAN, GUI_GAN, REN_GAN, XIN_GAN, GENG_GAN, JI_GAN, WU_GAN, YI_GAN, BING_GAN)); // 阴遁七局（1~9宫）
            put(8, Arrays.asList(BING_GAN, DING_GAN, GUI_GAN, REN_GAN, XIN_GAN, GENG_GAN, JI_GAN, WU_GAN, YI_GAN)); // 阴遁八局（1~9宫）
            put(9, Arrays.asList(YI_GAN, BING_GAN, DING_GAN, GUI_GAN, REN_GAN, XIN_GAN, GENG_GAN, JI_GAN, WU_GAN)); // 阴遁九局（1~9宫）
        }

    };

//------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 地盘六甲隐位（阳遁1~9宫）
     */
    public static final Map<Integer, List<String>> DI_YANG_LIU_JIA = new HashMap<Integer, List<String>>() {
        private static final long serialVersionUID = -1;

        // 例如→ 阳遁一局：甲子隐在坎一宫，甲戌隐在坤二宫，甲申隐在震三宫，甲午隐在巽四宫，甲辰隐在中五宫、寄坤二宫，甲寅隐在乾六宫。
        {
            put(1, Arrays.asList(JIA_ZI, JIA_XU, JIA_SHEN, JIA_WU, JIA_CHEN, JIA_YIN, "", "", "")); // 阳遁一局（1~9宫）
            put(2, Arrays.asList("", JIA_ZI, JIA_XU, JIA_SHEN, JIA_WU, JIA_CHEN, JIA_YIN, "", "")); // 阳遁二局（1~9宫）
            put(3, Arrays.asList("", "", JIA_ZI, JIA_XU, JIA_SHEN, JIA_WU, JIA_CHEN, JIA_YIN, "")); // 阳遁三局（1~9宫）
            put(4, Arrays.asList("", "", "", JIA_ZI, JIA_XU, JIA_SHEN, JIA_WU, JIA_CHEN, JIA_YIN)); // 阳遁四局（1~9宫）
            put(5, Arrays.asList(JIA_YIN, "", "", "", JIA_ZI, JIA_XU, JIA_SHEN, JIA_WU, JIA_CHEN)); // 阳遁五局（1~9宫）
            put(6, Arrays.asList(JIA_CHEN, JIA_YIN, "", "", "", JIA_ZI, JIA_XU, JIA_SHEN, JIA_WU)); // 阳遁六局（1~9宫）
            put(7, Arrays.asList(JIA_WU, JIA_CHEN, JIA_YIN, "", "", "", JIA_ZI, JIA_XU, JIA_SHEN)); // 阳遁七局（1~9宫）
            put(8, Arrays.asList(JIA_SHEN, JIA_WU, JIA_CHEN, JIA_YIN, "", "", "", JIA_ZI, JIA_XU)); // 阳遁八局（1~9宫）
            put(9, Arrays.asList(JIA_XU, JIA_SHEN, JIA_WU, JIA_CHEN, JIA_YIN, "", "", "", JIA_ZI)); // 阳遁九局（1~9宫）
        }

    };

    /**
     * 地盘六甲隐位（阴遁1~9宫）
     */
    public static final Map<Integer, List<String>> DI_YIN_LIU_JIA = new HashMap<Integer, List<String>>() {
        private static final long serialVersionUID = -1;

        // 例如→ 阴遁一局：甲子隐在坎一宫，甲戌隐在离九宫，甲申隐在艮八宫，甲午隐在兑七宫，甲辰隐在乾六宫，甲寅隐在中五宫、寄坤二宫。
        {
            put(1, Arrays.asList(JIA_ZI, "", "", "", JIA_YIN, JIA_CHEN, JIA_WU, JIA_SHEN, JIA_XU)); // 阴遁一局（1~9宫）
            put(2, Arrays.asList(JIA_XU, JIA_ZI, "", "", "", JIA_YIN, JIA_CHEN, JIA_WU, JIA_SHEN)); // 阴遁二局（1~9宫）
            put(3, Arrays.asList(JIA_SHEN, JIA_XU, JIA_ZI, "", "", "", JIA_YIN, JIA_CHEN, JIA_WU)); // 阴遁三局（1~9宫）
            put(4, Arrays.asList(JIA_WU, JIA_SHEN, JIA_XU, JIA_ZI, "", "", "", JIA_YIN, JIA_CHEN)); // 阴遁四局（1~9宫）
            put(5, Arrays.asList(JIA_CHEN, JIA_WU, JIA_SHEN, JIA_XU, JIA_ZI, "", "", "", JIA_YIN)); // 阴遁五局（1~9宫）
            put(6, Arrays.asList(JIA_YIN, JIA_CHEN, JIA_WU, JIA_SHEN, JIA_XU, JIA_ZI, "", "", "")); // 阴遁六局（1~9宫）
            put(7, Arrays.asList("", JIA_YIN, JIA_CHEN, JIA_WU, JIA_SHEN, JIA_XU, JIA_ZI, "", "")); // 阴遁七局（1~9宫）
            put(8, Arrays.asList("", "", JIA_YIN, JIA_CHEN, JIA_WU, JIA_SHEN, JIA_XU, JIA_ZI, "")); // 阴遁八局（1~9宫）
            put(9, Arrays.asList("", "", "", JIA_YIN, JIA_CHEN, JIA_WU, JIA_SHEN, JIA_XU, JIA_ZI)); // 阴遁九局（1~9宫）
        }

    };

//------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 九星原始宫位（1~9宫）
     */
    public static final String[] JIU_XING_INITIAL = {TIAN_PENG, TIAN_RUI, TIAN_CHONG, TIAN_FU, TIAN_QIN, TIAN_XIN, TIAN_ZHU, TIAN_REN, TIAN_YING};

    /**
     * 九星原始宫位（1~9宫）
     */
    public static final Map<String, Integer> JIU_XING_INITIAL2 = new HashMap<String, Integer>() {
        private static final long serialVersionUID = -1;

        {
            put(TIAN_PENG, 1);  // 天蓬：坎一宫
            put(TIAN_RUI, 2);   // 天芮：坤二宫
            put(TIAN_CHONG, 3); // 天冲：震三宫
            put(TIAN_FU, 4);    // 天辅：巽四宫
            put(TIAN_QIN, 5);   // 天禽：中五宫
            put(TIAN_XIN, 6);   // 天心：乾六宫
            put(TIAN_ZHU, 7);   // 天柱：兑七宫
            put(TIAN_REN, 8);   // 天任：艮八宫
            put(TIAN_YING, 9);  // 天英：离九宫
        }

    };

    /**
     * 九星位置（顺飞九宫）
     */
    public static final Map<Integer, List<String>> JIU_XING_SHUN_FEI = new HashMap<Integer, List<String>>() {
        private static final long serialVersionUID = -1;

        /* 以[天蓬星]为基准 */

        {
            // 1~9宫
            put(0, Arrays.asList(TIAN_PENG, TIAN_RUI, TIAN_CHONG, TIAN_FU, TIAN_QIN, TIAN_XIN, TIAN_ZHU, TIAN_REN, TIAN_YING)); // 天蓬星落坎一宫
            put(1, Arrays.asList(TIAN_YING, TIAN_PENG, TIAN_RUI, TIAN_CHONG, TIAN_FU, TIAN_QIN, TIAN_XIN, TIAN_ZHU, TIAN_REN)); // 天蓬星落坤二宫
            put(2, Arrays.asList(TIAN_REN, TIAN_YING, TIAN_PENG, TIAN_RUI, TIAN_CHONG, TIAN_FU, TIAN_QIN, TIAN_XIN, TIAN_ZHU)); // 天蓬星落震三宫
            put(3, Arrays.asList(TIAN_ZHU, TIAN_REN, TIAN_YING, TIAN_PENG, TIAN_RUI, TIAN_CHONG, TIAN_FU, TIAN_QIN, TIAN_XIN)); // 天蓬星落巽四宫
            put(4, Arrays.asList(TIAN_XIN, TIAN_ZHU, TIAN_REN, TIAN_YING, TIAN_PENG, TIAN_RUI, TIAN_CHONG, TIAN_FU, TIAN_QIN)); // 天蓬星落中五宫
            put(5, Arrays.asList(TIAN_QIN, TIAN_XIN, TIAN_ZHU, TIAN_REN, TIAN_YING, TIAN_PENG, TIAN_RUI, TIAN_CHONG, TIAN_FU)); // 天蓬星落乾六宫
            put(6, Arrays.asList(TIAN_FU, TIAN_QIN, TIAN_XIN, TIAN_ZHU, TIAN_REN, TIAN_YING, TIAN_PENG, TIAN_RUI, TIAN_CHONG)); // 天蓬星落兑七宫
            put(7, Arrays.asList(TIAN_CHONG, TIAN_FU, TIAN_QIN, TIAN_XIN, TIAN_ZHU, TIAN_REN, TIAN_YING, TIAN_PENG, TIAN_RUI)); // 天蓬星落艮八宫
            put(8, Arrays.asList(TIAN_RUI, TIAN_CHONG, TIAN_FU, TIAN_QIN, TIAN_XIN, TIAN_ZHU, TIAN_REN, TIAN_YING, TIAN_PENG)); // 天蓬星落离九宫
        }

    };

    /**
     * 九星位置（逆飞九宫）
     */
    public static final Map<Integer, List<String>> JIU_XING_NI_FEI = new HashMap<Integer, List<String>>() {
        private static final long serialVersionUID = -1;

        /* 以[天蓬星]为基准 */

        {
            // 1~9宫
            put(0, Arrays.asList(TIAN_PENG, TIAN_YING, TIAN_REN, TIAN_ZHU, TIAN_XIN, TIAN_QIN, TIAN_FU, TIAN_CHONG, TIAN_RUI)); // 天蓬星落坎一宫
            put(1, Arrays.asList(TIAN_RUI, TIAN_PENG, TIAN_YING, TIAN_REN, TIAN_ZHU, TIAN_XIN, TIAN_QIN, TIAN_FU, TIAN_CHONG)); // 天蓬星落坤二宫
            put(2, Arrays.asList(TIAN_CHONG, TIAN_RUI, TIAN_PENG, TIAN_YING, TIAN_REN, TIAN_ZHU, TIAN_XIN, TIAN_QIN, TIAN_FU)); // 天蓬星落震三宫
            put(3, Arrays.asList(TIAN_FU, TIAN_CHONG, TIAN_RUI, TIAN_PENG, TIAN_YING, TIAN_REN, TIAN_ZHU, TIAN_XIN, TIAN_QIN)); // 天蓬星落巽四宫
            put(4, Arrays.asList(TIAN_QIN, TIAN_FU, TIAN_CHONG, TIAN_RUI, TIAN_PENG, TIAN_YING, TIAN_REN, TIAN_ZHU, TIAN_XIN)); // 天蓬星落中五宫
            put(5, Arrays.asList(TIAN_XIN, TIAN_QIN, TIAN_FU, TIAN_CHONG, TIAN_RUI, TIAN_PENG, TIAN_YING, TIAN_REN, TIAN_ZHU)); // 天蓬星落乾六宫
            put(6, Arrays.asList(TIAN_ZHU, TIAN_XIN, TIAN_QIN, TIAN_FU, TIAN_CHONG, TIAN_RUI, TIAN_PENG, TIAN_YING, TIAN_REN)); // 天蓬星落兑七宫
            put(7, Arrays.asList(TIAN_REN, TIAN_ZHU, TIAN_XIN, TIAN_QIN, TIAN_FU, TIAN_CHONG, TIAN_RUI, TIAN_PENG, TIAN_YING)); // 天蓬星落艮八宫
            put(8, Arrays.asList(TIAN_YING, TIAN_REN, TIAN_ZHU, TIAN_XIN, TIAN_QIN, TIAN_FU, TIAN_CHONG, TIAN_RUI, TIAN_PENG)); // 天蓬星落离九宫
        }

    };

//------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 九门原始宫位（1~9宫）
     */
    public static final String[] JIU_MEN_INITIAL = {XIU_MEN, SI_MEN, SHANG_MEN, DU_MEN, ZHONG_MEN, KAI_MEN, JING_MEN_2, SHENG_MEN, JING_MEN_1};

    /**
     * 九门位置（顺飞九宫）
     */
    public static final Map<Integer, List<String>> JIU_MEN_SHUN_FEI = new HashMap<Integer, List<String>>() {
        private static final long serialVersionUID = -1;

        /* 以[休门]为基准 */

        {
            // 1~9宫
            put(0, Arrays.asList(XIU_MEN, SI_MEN, SHANG_MEN, DU_MEN, ZHONG_MEN, KAI_MEN, JING_MEN_2, SHENG_MEN, JING_MEN_1)); // 休门落坎一宫
            put(1, Arrays.asList(JING_MEN_1, XIU_MEN, SI_MEN, SHANG_MEN, DU_MEN, ZHONG_MEN, KAI_MEN, JING_MEN_2, SHENG_MEN)); // 休门落坤二宫
            put(2, Arrays.asList(SHENG_MEN, JING_MEN_1, XIU_MEN, SI_MEN, SHANG_MEN, DU_MEN, ZHONG_MEN, KAI_MEN, JING_MEN_2)); // 休门落震三宫
            put(3, Arrays.asList(JING_MEN_2, SHENG_MEN, JING_MEN_1, XIU_MEN, SI_MEN, SHANG_MEN, DU_MEN, ZHONG_MEN, KAI_MEN)); // 休门落巽四宫
            put(4, Arrays.asList(KAI_MEN, JING_MEN_2, SHENG_MEN, JING_MEN_1, XIU_MEN, SI_MEN, SHANG_MEN, DU_MEN, ZHONG_MEN)); // 休门落中五宫
            put(5, Arrays.asList(ZHONG_MEN, KAI_MEN, JING_MEN_2, SHENG_MEN, JING_MEN_1, XIU_MEN, SI_MEN, SHANG_MEN, DU_MEN)); // 休门落乾六宫
            put(6, Arrays.asList(DU_MEN, ZHONG_MEN, KAI_MEN, JING_MEN_2, SHENG_MEN, JING_MEN_1, XIU_MEN, SI_MEN, SHANG_MEN)); // 休门落兑七宫
            put(7, Arrays.asList(SHANG_MEN, DU_MEN, ZHONG_MEN, KAI_MEN, JING_MEN_2, SHENG_MEN, JING_MEN_1, XIU_MEN, SI_MEN)); // 休门落艮八宫
            put(8, Arrays.asList(SI_MEN, SHANG_MEN, DU_MEN, ZHONG_MEN, KAI_MEN, JING_MEN_2, SHENG_MEN, JING_MEN_1, XIU_MEN)); // 休门落离九宫
        }

    };

    /**
     * 九门位置（逆飞九宫）
     */
    public static final Map<Integer, List<String>> JIU_MEN_NI_FEI = new HashMap<Integer, List<String>>() {
        private static final long serialVersionUID = -1;

        /* 以[休门]为基准 */

        {
            // 1~9宫
            put(0, Arrays.asList(XIU_MEN, JING_MEN_1, SHENG_MEN, JING_MEN_2, KAI_MEN, ZHONG_MEN, DU_MEN, SHANG_MEN, SI_MEN)); // 休门落坎一宫
            put(1, Arrays.asList(SI_MEN, XIU_MEN, JING_MEN_1, SHENG_MEN, JING_MEN_2, KAI_MEN, ZHONG_MEN, DU_MEN, SHANG_MEN)); // 休门落坤二宫
            put(2, Arrays.asList(SHANG_MEN, SI_MEN, XIU_MEN, JING_MEN_1, SHENG_MEN, JING_MEN_2, KAI_MEN, ZHONG_MEN, DU_MEN)); // 休门落震三宫
            put(3, Arrays.asList(DU_MEN, SHANG_MEN, SI_MEN, XIU_MEN, JING_MEN_1, SHENG_MEN, JING_MEN_2, KAI_MEN, ZHONG_MEN)); // 休门落巽四宫
            put(4, Arrays.asList(ZHONG_MEN, DU_MEN, SHANG_MEN, SI_MEN, XIU_MEN, JING_MEN_1, SHENG_MEN, JING_MEN_2, KAI_MEN)); // 休门落中五宫
            put(5, Arrays.asList(KAI_MEN, ZHONG_MEN, DU_MEN, SHANG_MEN, SI_MEN, XIU_MEN, JING_MEN_1, SHENG_MEN, JING_MEN_2)); // 休门落乾六宫
            put(6, Arrays.asList(JING_MEN_2, KAI_MEN, ZHONG_MEN, DU_MEN, SHANG_MEN, SI_MEN, XIU_MEN, JING_MEN_1, SHENG_MEN)); // 休门落兑七宫
            put(7, Arrays.asList(SHENG_MEN, JING_MEN_2, KAI_MEN, ZHONG_MEN, DU_MEN, SHANG_MEN, SI_MEN, XIU_MEN, JING_MEN_1)); // 休门落艮八宫
            put(8, Arrays.asList(JING_MEN_1, SHENG_MEN, JING_MEN_2, KAI_MEN, ZHONG_MEN, DU_MEN, SHANG_MEN, SI_MEN, XIU_MEN)); // 休门落离九宫
        }

    };

    /**
     * 八门位置（顺转九宫）
     */
    public static final Map<Integer, List<String>> BA_MEN_SHUN_ZHUAN = new HashMap<Integer, List<String>>() {
        private static final long serialVersionUID = -1;

        /* 以[休门]为基准 */

        {
            // 1~9宫
            put(0, Arrays.asList(XIU_MEN, SI_MEN, SHANG_MEN, DU_MEN, "", KAI_MEN, JING_MEN_2, SHENG_MEN, JING_MEN_1)); // 休门落坎一宫
            put(1, Arrays.asList(DU_MEN, XIU_MEN, SI_MEN, JING_MEN_2, "", SHANG_MEN, SHENG_MEN, JING_MEN_1, KAI_MEN)); // 休门落坤二宫
            put(2, Arrays.asList(JING_MEN_2, DU_MEN, XIU_MEN, SHENG_MEN, "", SI_MEN, JING_MEN_1, KAI_MEN, SHANG_MEN)); // 休门落震三宫
            put(3, Arrays.asList(SI_MEN, SHANG_MEN, KAI_MEN, XIU_MEN, "", JING_MEN_1, DU_MEN, JING_MEN_2, SHENG_MEN)); // 休门落巽四宫
            put(4, Arrays.asList(DU_MEN, XIU_MEN, SI_MEN, JING_MEN_2, "", SHANG_MEN, SHENG_MEN, JING_MEN_1, KAI_MEN)); // 休门落中五宫（按坤二宫计算）
            put(5, Arrays.asList(SHENG_MEN, JING_MEN_2, DU_MEN, JING_MEN_1, "", XIU_MEN, KAI_MEN, SHANG_MEN, SI_MEN)); // 休门落乾六宫
            put(6, Arrays.asList(SHANG_MEN, KAI_MEN, JING_MEN_1, SI_MEN, "", SHENG_MEN, XIU_MEN, DU_MEN, JING_MEN_2)); // 休门落兑七宫
            put(7, Arrays.asList(KAI_MEN, JING_MEN_1, SHENG_MEN, SHANG_MEN, "", JING_MEN_2, SI_MEN, XIU_MEN, DU_MEN)); // 休门落艮八宫
            put(8, Arrays.asList(JING_MEN_1, SHENG_MEN, JING_MEN_2, KAI_MEN, "", DU_MEN, SHANG_MEN, SI_MEN, XIU_MEN)); // 休门落离九宫
        }

    };

    /**
     * 八门位置（逆转九宫）
     */
    public static final Map<Integer, List<String>> BA_MEN_NI_ZHUAN = new HashMap<Integer, List<String>>() {
        private static final long serialVersionUID = -1;

        /* 以[休门]为基准 */

        {
            // 1~9宫
            put(0, Arrays.asList(XIU_MEN, DU_MEN, JING_MEN_2, SI_MEN, "", SHENG_MEN, SHANG_MEN, KAI_MEN, JING_MEN_1)); // 休门落坎一宫
            put(1, Arrays.asList(SI_MEN, XIU_MEN, DU_MEN, SHANG_MEN, "", JING_MEN_2, KAI_MEN, JING_MEN_1, XIU_MEN)); // 休门落坤二宫
            put(2, Arrays.asList(SHANG_MEN, SI_MEN, XIU_MEN, KAI_MEN, "", DU_MEN, JING_MEN_1, SHENG_MEN, JING_MEN_2)); // 休门落震三宫
            put(3, Arrays.asList(DU_MEN, JING_MEN_2, SHENG_MEN, XIU_MEN, "", JING_MEN_1, SI_MEN, SHANG_MEN, KAI_MEN)); // 休门落巽四宫
            put(4, Arrays.asList(SI_MEN, XIU_MEN, DU_MEN, SHANG_MEN, "", JING_MEN_2, KAI_MEN, JING_MEN_1, XIU_MEN)); // 休门落中五宫（按坤二宫计算）
            put(5, Arrays.asList(KAI_MEN, SHANG_MEN, SI_MEN, JING_MEN_1, "", XIU_MEN, SHENG_MEN, JING_MEN_2, DU_MEN)); // 休门落乾六宫
            put(6, Arrays.asList(JING_MEN_2, SHENG_MEN, JING_MEN_1, DU_MEN, "", KAI_MEN, XIU_MEN, SI_MEN, SHANG_MEN)); // 休门落兑七宫
            put(7, Arrays.asList(SHENG_MEN, JING_MEN_1, KAI_MEN, JING_MEN_2, "", SHANG_MEN, DU_MEN, XIU_MEN, SI_MEN)); // 休门落艮八宫
            put(8, Arrays.asList(JING_MEN_1, KAI_MEN, SHANG_MEN, SHENG_MEN, "", SI_MEN, JING_MEN_2, DU_MEN, XIU_MEN)); // 休门落离九宫
        }

    };

//------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 九神原始宫位（1~9宫）
     */
    public static final String[] JIU_SHEN = {ZHI_FU, TENG_SHE, TAI_YIN, LIU_HE, GOU_CHEN, TAI_CHANG, ZHU_QUE, JIU_DI, JIU_TIAN};

    /**
     * 九神位置（顺飞九宫）
     */
    public static final Map<Integer, List<String>> JIU_SHEN_SHUN_FEI = new HashMap<Integer, List<String>>() {
        private static final long serialVersionUID = -1;

        /* 以[值符]为基准 */

        {
            // 1~9宫
            put(0, Arrays.asList(ZHI_FU, TENG_SHE, TAI_YIN, LIU_HE, GOU_CHEN, TAI_CHANG, ZHU_QUE, JIU_DI, JIU_TIAN)); // 值符落坎一宫
            put(1, Arrays.asList(JIU_TIAN, ZHI_FU, TENG_SHE, TAI_YIN, LIU_HE, GOU_CHEN, TAI_CHANG, ZHU_QUE, JIU_DI)); // 值符落坤二宫
            put(2, Arrays.asList(JIU_DI, JIU_TIAN, ZHI_FU, TENG_SHE, TAI_YIN, LIU_HE, GOU_CHEN, TAI_CHANG, ZHU_QUE)); // 值符落震三宫
            put(3, Arrays.asList(ZHU_QUE, JIU_DI, JIU_TIAN, ZHI_FU, TENG_SHE, TAI_YIN, LIU_HE, GOU_CHEN, TAI_CHANG)); // 值符落巽四宫
            put(4, Arrays.asList(TAI_CHANG, ZHU_QUE, JIU_DI, JIU_TIAN, ZHI_FU, TENG_SHE, TAI_YIN, LIU_HE, GOU_CHEN)); // 值符落中五宫
            put(5, Arrays.asList(GOU_CHEN, TAI_CHANG, ZHU_QUE, JIU_DI, JIU_TIAN, ZHI_FU, TENG_SHE, TAI_YIN, LIU_HE)); // 值符落乾六宫
            put(6, Arrays.asList(LIU_HE, GOU_CHEN, TAI_CHANG, ZHU_QUE, JIU_DI, JIU_TIAN, ZHI_FU, TENG_SHE, TAI_YIN)); // 值符落兑七宫
            put(7, Arrays.asList(TAI_YIN, LIU_HE, GOU_CHEN, TAI_CHANG, ZHU_QUE, JIU_DI, JIU_TIAN, ZHI_FU, TENG_SHE)); // 值符落艮八宫
            put(8, Arrays.asList(TENG_SHE, TAI_YIN, LIU_HE, GOU_CHEN, TAI_CHANG, ZHU_QUE, JIU_DI, JIU_TIAN, ZHI_FU)); // 值符落离九宫
        }

    };

    /**
     * 九神位置（逆飞九宫）
     */
    public static final Map<Integer, List<String>> JIU_SHEN_NI_FEI = new HashMap<Integer, List<String>>() {
        private static final long serialVersionUID = -1;

        /* 以[值符]为基准 */

        {
            // 1~9宫
            put(0, Arrays.asList(ZHI_FU, JIU_TIAN, JIU_DI, ZHU_QUE, TAI_CHANG, GOU_CHEN, LIU_HE, TAI_YIN, TENG_SHE)); // 值符落坎一宫
            put(1, Arrays.asList(TENG_SHE, ZHI_FU, JIU_TIAN, JIU_DI, ZHU_QUE, TAI_CHANG, GOU_CHEN, LIU_HE, TAI_YIN)); // 值符落坤二宫
            put(2, Arrays.asList(TAI_YIN, TENG_SHE, ZHI_FU, JIU_TIAN, JIU_DI, ZHU_QUE, TAI_CHANG, GOU_CHEN, LIU_HE)); // 值符落震三宫
            put(3, Arrays.asList(LIU_HE, TAI_YIN, TENG_SHE, ZHI_FU, JIU_TIAN, JIU_DI, ZHU_QUE, TAI_CHANG, GOU_CHEN)); // 值符落巽四宫
            put(4, Arrays.asList(GOU_CHEN, LIU_HE, TAI_YIN, TENG_SHE, ZHI_FU, JIU_TIAN, JIU_DI, ZHU_QUE, TAI_CHANG)); // 值符落中五宫
            put(5, Arrays.asList(TAI_CHANG, GOU_CHEN, LIU_HE, TAI_YIN, TENG_SHE, ZHI_FU, JIU_TIAN, JIU_DI, ZHU_QUE)); // 值符落乾六宫
            put(6, Arrays.asList(ZHU_QUE, TAI_CHANG, GOU_CHEN, LIU_HE, TAI_YIN, TENG_SHE, ZHI_FU, JIU_TIAN, JIU_DI)); // 值符落兑七宫
            put(7, Arrays.asList(JIU_DI, ZHU_QUE, TAI_CHANG, GOU_CHEN, LIU_HE, TAI_YIN, TENG_SHE, ZHI_FU, JIU_TIAN)); // 值符落艮八宫
            put(8, Arrays.asList(JIU_TIAN, JIU_DI, ZHU_QUE, TAI_CHANG, GOU_CHEN, LIU_HE, TAI_YIN, TENG_SHE, ZHI_FU)); // 值符落离九宫
        }

    };

//------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 六甲旬空
     */
    public static final Map<String, List<String>> LIU_JIA_XUN_KONG = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            甲子旬戌亥空，甲戌旬申酉空；
            甲申旬午未空，甲午旬辰巳空；
            甲辰旬寅卯空，甲寅旬子丑空。

            ★注：忌神落空则为喜、喜神落空则为凶

         */

        {
            put(JIA_ZI, Arrays.asList(XU_ZHI, HAI_ZHI));   // 甲子旬：戌亥空
            put(JIA_XU, Arrays.asList(SHEN_ZHI, YOU_ZHI)); // 甲戌旬：申酉空
            put(JIA_SHEN, Arrays.asList(WU_ZHI, WEI_ZHI));   // 甲申旬：午未空
            put(JIA_WU, Arrays.asList(CHEN_ZHI, SI_ZHI));  // 甲午旬：辰巳空
            put(JIA_CHEN, Arrays.asList(YIN_ZHI, MAO_ZHI));  // 甲辰旬：寅卯空
            put(JIA_YIN, Arrays.asList(ZI_ZHI, CHOU_ZHI));  // 甲寅旬：子丑空
        }

    };

    /**
     * 六甲旬空落宫
     */
    public static final Map<List<String>, List<Integer>> LIU_JIA_XUN_KONG_GONG = new HashMap<List<String>, List<Integer>>() {
        private static final long serialVersionUID = -1;

        {
            put(Arrays.asList(XU_ZHI, HAI_ZHI), Collections.singletonList(6));  // 戌亥空：落乾六宫
            put(Arrays.asList(SHEN_ZHI, YOU_ZHI), Arrays.asList(2, 7));         // 申酉空：落坤二宫、兑七宫
            put(Arrays.asList(WU_ZHI, WEI_ZHI), Arrays.asList(9, 2));           // 午未空：落离九宫、坤二宫
            put(Arrays.asList(CHEN_ZHI, SI_ZHI), Collections.singletonList(4)); // 辰巳空：落巽四宫
            put(Arrays.asList(YIN_ZHI, MAO_ZHI), Arrays.asList(8, 3));          // 寅卯空：落艮八宫、震三宫
            put(Arrays.asList(ZI_ZHI, CHOU_ZHI), Arrays.asList(1, 8));          // 子丑空：落坎一宫、艮八宫
        }

    };

//------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 驿马
     */
    public static final Map<String, String> YI_MA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            根据时支判断→ 申子辰马在寅，寅午戌马在申，巳酉丑马在亥，亥卯未马在巳
         */

        {
            put(SHEN_ZHI, YIN_ZHI); // 申：马在寅
            put(ZI_ZHI, YIN_ZHI);   // 子：马在寅
            put(CHEN_ZHI, YIN_ZHI); // 辰：马在寅
            put(YIN_ZHI, SHEN_ZHI); // 寅：马在申
            put(WU_ZHI, SHEN_ZHI);  // 午：马在申
            put(XU_ZHI, SHEN_ZHI);  // 戌：马在申
            put(SI_ZHI, HAI_ZHI);   // 巳：马在亥
            put(YOU_ZHI, HAI_ZHI);  // 酉：马在亥
            put(CHOU_ZHI, HAI_ZHI); // 丑：马在亥
            put(HAI_ZHI, SI_ZHI);   // 亥：马在巳
            put(MAO_ZHI, SI_ZHI);   // 卯：马在巳
            put(WEI_ZHI, SI_ZHI);   // 未：马在巳
        }

    };

    /**
     * 驿马落宫
     */
    public static final Map<String, Integer> YI_MA_GONG = new HashMap<String, Integer>() {
        private static final long serialVersionUID = -1;

        /*
            根据时支判断→ 寅马在艮八宫，申马在坤二宫，巳马在巽四宫，亥马在乾六宫
         */

        {
            put(YIN_ZHI, 8);  // 寅：马在艮八宫
            put(SHEN_ZHI, 2); // 申：马在坤二宫
            put(SI_ZHI, 4);   // 巳：马在巽四宫
            put(HAI_ZHI, 6);  // 亥：马在乾六宫
        }

    };

//------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 十干克应
     */
    public static final Map<List<String>, List<String>> SHI_GAN_KE_YING = new HashMap<List<String>, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            十干克应：天盘天干和地盘天干相遇后的各种克应关系。

                1、奇门遁甲将甲隐遁起来，其余九干又分成三奇和六仪，所以也就是奇仪之间的克应关系；
                2、即天盘[乙、丙、丁、戊、己、庚、辛、壬、癸]和地盘[乙、丙、丁、戊、己、庚、辛、壬、癸]相遇后的各种关系。
        */

        {
            // 例如→ 天盘乙奇+地盘乙奇（日奇伏吟）：宜安分守已、积粮藏宝、莳花种果等；不宜见上层领导、贵人、求名求利等。
            put(Arrays.asList(YI_GAN, YI_GAN), Arrays.asList("日奇伏吟", "宜安分守已、积粮藏宝、莳花种果等；不宜见上层领导、贵人、求名求利等。"));
            put(Arrays.asList(YI_GAN, BING_GAN), Arrays.asList("奇仪顺遂", "吉星迁官晋职，凶星夫妻反目离别。"));
            put(Arrays.asList(YI_GAN, DING_GAN), Arrays.asList("奇仪相佐", "最利文书、考试，百事可为。"));
            put(Arrays.asList(YI_GAN, WU_GAN), Arrays.asList("阴害阳门", "利于阴人、阴事，不利阳人、阳事，得门吉尚可谋为，得门凶、门迫则破财伤人。"));
            put(Arrays.asList(YI_GAN, JI_GAN), Arrays.asList("日奇入墓", "门凶事必凶，得生、开二吉门为地遁。"));
            put(Arrays.asList(YI_GAN, GENG_GAN), Arrays.asList("日奇被刑", "为争讼财产，夫妻怀有私意。"));
            put(Arrays.asList(YI_GAN, XIN_GAN), Arrays.asList("青龙逃走", "此时不宜举兵，主将士逃窜，临阵败亡，所谋百事皆凶，财利倾覆，身遭残毁；通常代表君子主动离开恶劣环境、人才流失、人才出走、君子遭遇困境、险境而主动逃离等。测婚一般主女方先提出离婚。"));
            put(Arrays.asList(YI_GAN, REN_GAN), Arrays.asList("日奇入地", "尊卑悖乱，官讼是非，有人谋害之事。"));
            put(Arrays.asList(YI_GAN, GUI_GAN), Arrays.asList("华盖逢星", "遁迹修道，隐匿藏形，躲灾避难为吉。"));

            put(Arrays.asList(BING_GAN, YI_GAN), Arrays.asList("日月并行", "公谋私为皆吉。"));
            put(Arrays.asList(BING_GAN, BING_GAN), Arrays.asList("月奇悖师", "文书逼迫，破耗遗失，主单据票证不明遗失。"));
            put(Arrays.asList(BING_GAN, DING_GAN), Arrays.asList("星奇朱雀", "贵人文书吉利，常人平静安乐，得三吉门为天遁。"));
            put(Arrays.asList(BING_GAN, WU_GAN), Arrays.asList("飞鸟跌穴", "百事吉，事业可为，可谋大事。"));
            put(Arrays.asList(BING_GAN, JI_GAN), Arrays.asList("大悖入刑", "坐监牢，被杖责，文书公文不能传递，得吉门则吉，得凶门则转吉为凶。"));
            put(Arrays.asList(BING_GAN, GENG_GAN), Arrays.asList("萤入太白/火入金乡", "门户破败，盗贼耗失，事业亦凶；火入金乡贼即去。"));
            put(Arrays.asList(BING_GAN, XIN_GAN), Arrays.asList("丙辛相和", "故谋事能成，为疾病人不凶。"));
            put(Arrays.asList(BING_GAN, REN_GAN), Arrays.asList("火入天罗", "为客不利，是非颇多。"));
            put(Arrays.asList(BING_GAN, GUI_GAN), Arrays.asList("华盖悖师", "阴人害事，灾祸频生。"));

            put(Arrays.asList(DING_GAN, YI_GAN), Arrays.asList("人遁吉格", "贵人加官晋爵，常人婚姻财帛有喜。"));
            put(Arrays.asList(DING_GAN, BING_GAN), Arrays.asList("星随月转", "贵人越级高升，常人乐极生悲；需忍耐，否则会因小失大而不幸。"));
            put(Arrays.asList(DING_GAN, DING_GAN), Arrays.asList("星奇入太阴", "文书证件即至，喜事从心，万事如意。"));
            put(Arrays.asList(DING_GAN, WU_GAN), Arrays.asList("青龙转光", "官人升迁，常人威昌。"));
            put(Arrays.asList(DING_GAN, JI_GAN), Arrays.asList("火入勾陈", "奸私仇怨，事因女人。"));
            put(Arrays.asList(DING_GAN, GENG_GAN), Arrays.asList("文书阻隔", "行人必归。"));
            put(Arrays.asList(DING_GAN, XIN_GAN), Arrays.asList("朱雀入狱", "罪人释囚，官人失位。"));
            put(Arrays.asList(DING_GAN, REN_GAN), Arrays.asList("丁壬相合", "主贵人恩诏，讼狱公平，测婚多为苟合。"));
            put(Arrays.asList(DING_GAN, GUI_GAN), Arrays.asList("朱雀投江", "文书口舌是非，惊动官府，词讼不利，音信沉溺不到。"));

            put(Arrays.asList(WU_GAN, YI_GAN), Arrays.asList("甲乙会和", "又名青龙会和，门吉事吉，门凶事凶。"));
            put(Arrays.asList(WU_GAN, BING_GAN), Arrays.asList("青龙返首", "为事所谋，大吉大利，若逢迫墓击邢，吉事也凶。"));
            put(Arrays.asList(WU_GAN, DING_GAN), Arrays.asList("青龙耀明", "谒贵求名吉利，若值墓、迫，惹是生非。"));
            put(Arrays.asList(WU_GAN, WU_GAN), Arrays.asList("甲甲比肩", "各谓伏吟，凡事不利，道路闭塞，以守为好。"));
            put(Arrays.asList(WU_GAN, JI_GAN), Arrays.asList("贵人入狱", "公司皆不利。"));
            put(Arrays.asList(WU_GAN, GENG_GAN), Arrays.asList("值符飞宫", "吉事不吉，凶事更凶，求财没利益，测病也主凶，同时甲庚相冲，也主换地方。"));
            put(Arrays.asList(WU_GAN, XIN_GAN), Arrays.asList("青龙折足", "子午相冲，吉门有生助，尚能谋事，若逢凶门，则招灾、失财或有足疾、折伤。"));
            put(Arrays.asList(WU_GAN, REN_GAN), Arrays.asList("青龙入天牢", "凡阴阳事皆不吉利。"));
            put(Arrays.asList(WU_GAN, GUI_GAN), Arrays.asList("青龙华盖", "甲为青龙，癸为天网，逢吉门为吉，可招福临门，逢凶门事多不利，为凶。"));

            put(Arrays.asList(JI_GAN, YI_GAN), Arrays.asList("墓神不明", "地户逢星，宜遁迹隐形为吉利。"));
            put(Arrays.asList(JI_GAN, BING_GAN), Arrays.asList("火悖地户", "男人冤冤相害，女人必致淫污。"));
            put(Arrays.asList(JI_GAN, DING_GAN), Arrays.asList("朱雀入墓", "文书词讼，先曲后直。"));
            put(Arrays.asList(JI_GAN, WU_GAN), Arrays.asList("犬遇青龙", "门吉为谋望遂意，上人见喜，若门凶，枉费心机。"));
            put(Arrays.asList(JI_GAN, JI_GAN), Arrays.asList("地户逢贵", "病者发凶或必死，百事不遂，暂不谋为，谋为则凶。"));
            put(Arrays.asList(JI_GAN, GENG_GAN), Arrays.asList("刑格返名", "词讼先动者不利，如临阴星则有谋害之情。"));
            put(Arrays.asList(JI_GAN, XIN_GAN), Arrays.asList("游魂入墓", "易遭阴邪鬼魅作祟。"));
            put(Arrays.asList(JI_GAN, REN_GAN), Arrays.asList("地网高张", "狡童佚女，奸情伤杀，凶。"));
            put(Arrays.asList(JI_GAN, GUI_GAN), Arrays.asList("地刑玄武", "男女疾病垂危，有囚狱词讼之灾。"));

            put(Arrays.asList(GENG_GAN, YI_GAN), Arrays.asList("太白逢星", "退吉进凶，谋为不利。"));
            put(Arrays.asList(GENG_GAN, BING_GAN), Arrays.asList("太白入萤", "占贼贼必来，须防贼来偷营。宜于西北方伏击之。以固守为吉。为客进利，为主破财。"));
            put(Arrays.asList(GENG_GAN, DING_GAN), Arrays.asList("亭亭之格", "因私匿或男女关系起官司是非，门吉有救，门凶事必凶。"));
            put(Arrays.asList(GENG_GAN, WU_GAN), Arrays.asList("天乙伏宫", "百事不可谋，大凶。"));
            put(Arrays.asList(GENG_GAN, JI_GAN), Arrays.asList("官符刑格", "主有官司口舌，因官讼被判刑，住牢狱更凶。"));
            put(Arrays.asList(GENG_GAN, GENG_GAN), Arrays.asList("太白同宫", "又名战格，官灾横祸，兄弟或同辈朋友相冲撞，不利为事。"));
            put(Arrays.asList(GENG_GAN, XIN_GAN), Arrays.asList("白虎干格", "不宜远行，远行车折马伤，求财更为大凶。"));
            put(Arrays.asList(GENG_GAN, REN_GAN), Arrays.asList("上格", "远行道路迷失，男女音信难通。"));
            put(Arrays.asList(GENG_GAN, GUI_GAN), Arrays.asList("大格", "多主车祸，行人不至，官事不止，生育母子俱伤，大凶。"));

            put(Arrays.asList(XIN_GAN, YI_GAN), Arrays.asList("白虎猖狂", "家败人亡，远行多遭殃；测婚离散，主因男人。"));
            put(Arrays.asList(XIN_GAN, BING_GAN), Arrays.asList("干合悖师", "门吉则事吉，门凶事凶，测事易因财物致讼。"));
            put(Arrays.asList(XIN_GAN, DING_GAN), Arrays.asList("狱神得奇", "经商求财获利百倍，囚人逢天赦释免。"));
            put(Arrays.asList(XIN_GAN, WU_GAN), Arrays.asList("困龙被伤", "主官司破财，屈抑守分尚可，妄动则带来灾祸。"));
            put(Arrays.asList(XIN_GAN, JI_GAN), Arrays.asList("入狱自刑", "奴仆背主，有苦诉讼难伸。"));
            put(Arrays.asList(XIN_GAN, GENG_GAN), Arrays.asList("白虎出力", "刀刃相交，主客相残，逊让退步稍可，强进血溅衣衫。"));
            put(Arrays.asList(XIN_GAN, XIN_GAN), Arrays.asList("午午自刑", "伏吟天庭，公废私就，讼狱自罹罪名。"));
            put(Arrays.asList(XIN_GAN, REN_GAN), Arrays.asList("凶蛇入狱", "两男争女，讼狱不息，先动失理。"));
            put(Arrays.asList(XIN_GAN, GUI_GAN), Arrays.asList("天牢华盖", "日月失明，误入天网，动止乖张。"));

            put(Arrays.asList(REN_GAN, YI_GAN), Arrays.asList("小蛇得势", "女人柔顺，男人通达，测孕育生子，禄马光荣。"));
            put(Arrays.asList(REN_GAN, BING_GAN), Arrays.asList("水蛇入火", "主官灾刑禁，络绎不绝。"));
            put(Arrays.asList(REN_GAN, DING_GAN), Arrays.asList("干合蛇刑", "文书牵连，贵人匆匆，男吉女凶。"));
            put(Arrays.asList(REN_GAN, WU_GAN), Arrays.asList("小蛇化龙", "男人发达，女人产婴童。"));
            put(Arrays.asList(REN_GAN, JI_GAN), Arrays.asList("反吟蛇刑", "主官讼败诉，大祸将至，顺守可吉，妄动必灾。"));
            put(Arrays.asList(REN_GAN, GENG_GAN), Arrays.asList("太白擒蛇", "刑狱公平，立部刑正。"));
            put(Arrays.asList(REN_GAN, XIN_GAN), Arrays.asList("腾蛇相缠", "纵得吉门，亦不能安宁，若有谋望，被人欺瞒。"));
            put(Arrays.asList(REN_GAN, REN_GAN), Arrays.asList("蛇入地罗", "外人缠绕，内事索索，吉门吉星，庶免蹉跎。"));
            put(Arrays.asList(REN_GAN, GUI_GAN), Arrays.asList("幼女奸淫", "主有家丑外扬之事发生，门吉星凶，易反福为祸。"));

            put(Arrays.asList(GUI_GAN, YI_GAN), Arrays.asList("华盖逢星", "贵人禄位，常人平安，门吉则吉，门凶则凶。"));
            put(Arrays.asList(GUI_GAN, BING_GAN), Arrays.asList("华盖悖师", "贵贱逢之皆不利，惟上人见喜。"));
            put(Arrays.asList(GUI_GAN, DING_GAN), Arrays.asList("螣蛇夭矫", "文书官司，火焚也难逃。"));
            put(Arrays.asList(GUI_GAN, WU_GAN), Arrays.asList("天乙会和", "吉门易求财，婚姻喜美，吉人赞助成合；门凶迫制，反祸官非。"));
            put(Arrays.asList(GUI_GAN, JI_GAN), Arrays.asList("华盖地户", "男女测之，音信皆阻，此格宜躲灾避难方为吉。"));
            put(Arrays.asList(GUI_GAN, GENG_GAN), Arrays.asList("太白入网", "主以暴力争讼，自罹罪责。"));
            put(Arrays.asList(GUI_GAN, XIN_GAN), Arrays.asList("网盖天牢", "主官司败讼，死罪难逃，测病亦大凶。"));
            put(Arrays.asList(GUI_GAN, REN_GAN), Arrays.asList("复见螣蛇", "主嫁娶重婚，后嫁无子，不保年华。"));
            put(Arrays.asList(GUI_GAN, GUI_GAN), Arrays.asList("天网四张", "主行人失伴，病讼皆伤。"));
        }

    };

//------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 月将、月将神
     */
    public static final Map<String, List<String>> YUE_JIANG = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            正月建寅，寅与亥合，所以正月的月将为：亥，月将神为：登明
            二月建卯，卯与戌合，所以二月的月将为：戌，月将神为：河魁
            三月建辰，辰与酉合，所以三月的月将为：酉，月将神为：从魁
            四月建巳，巳与申合，所以四月的月将为：申，月将神为：传送
            五月建午，午与未合，所以五月的月将为：未，月将神为：小吉
            六月建未，未与午合，所以六月的月将为：午，月将神为：胜光
            七月建申，申与巳合，所以七月的月将为：巳，月将神为：太乙
            八月建酉，酉与辰合，所以八月的月将为：辰，月将神为：天罡
            九月建戌，戌与卯合，所以九月的月将为：卯，月将神为：太冲
            十月建亥，亥与寅合，所以十月的月将为：寅，月将神为：功曹
            十一月建子，子与丑合，所以十一月的月将为：丑，月将神为：大吉
            十二月建丑，丑与子合，所以十二月的月将为：子，月将神为：神后
        */

        {
            put(YIN_ZHI, Arrays.asList(HAI_ZHI, CHENG_MING));
            put(MAO_ZHI, Arrays.asList(XU_ZHI, HEI_KUI));
            put(CHEN_ZHI, Arrays.asList(YOU_ZHI, CONG_KUI));
            put(SI_ZHI, Arrays.asList(SHEN_ZHI, CHUAN_SONG));
            put(WU_ZHI, Arrays.asList(WEI_ZHI, XIAO_JI));
            put(WEI_ZHI, Arrays.asList(WU_ZHI, SHENG_GUANG));
            put(SHEN_ZHI, Arrays.asList(SI_ZHI, TAI_YI));
            put(YOU_ZHI, Arrays.asList(CHEN_ZHI, TIAN_GANG));
            put(XU_ZHI, Arrays.asList(MAO_ZHI, TAI_CHONG));
            put(HAI_ZHI, Arrays.asList(YIN_ZHI, GONG_CAO));
            put(ZI_ZHI, Arrays.asList(CHOU_ZHI, DA_JI));
            put(CHOU_ZHI, Arrays.asList(ZI_ZHI, SHEN_HOU));
        }

    };


}
